#coding:utf-8

#ultima versão funcional sem condicao de armijo

#Nao est� sendo usado no momento
class Matriz():

    def __init__(self,rows=None,cols=None):
        self.rows,self.cols = 0,0
        
        if rows is not None:
            self.rows = rows
        
        if cols is not None:
            self.cols = cols
        
        self.items = [ [0]*self.cols ]*self.rows
        
    def add_row(self,row):
        if self.cols == 0 :
            self.cols = len(row)
        elif self.cols != len(row):
            print "Erro ao adicionar linha com numero de colunas mais do que o esperado"
            return
            
        self.items.append( row )
        self.rows+=1
        
    def somar_matriz(self,matriz):
        if self.rows != matriz.rows:
            print "Nao se pode somar matrizes com numero diferente de linhas"
            return
        if self.cols != matriz.cols:
            print "Nao se pode somar matrizes com numero diferente de colunas"
            return        
        
        result = Matriz()
        
        for i in range(0,self.rows):
            linha_i = []
            for j in range(0,self.cols):
                linha_i.append( self.items[i][j] + matriz.items[i][j] )
                
            result.add_row(linha_i)
                
        return result
                    
                
    def somar_escalar(self,escalar):
        result = Matriz()
        
        for i in range(0,self.rows):
            linha_i=[]
            for j in range(0,self.cols):
                linha_i.append( self.items[i][j] + escalar )
            
            result.add_row(linha_i)
        
        return result
    
    def multiplicar_matriz(self,matriz):
        if self.cols != matriz.rows:
            print "Nao se pode multiplicar matrizes com numero de colunas diferente do numero de linhas do outro"
            return
        
        resultado = Matriz()
        
        for i in range(0,self.rows):
            linha_i = []
            for j in range(0,self.cols):                
                elem_i_j = 0
                for r in range(0,matriz.rows):
                    elem_i_j+=self.items[i][r]*matriz.items[r][j]
                
                linha_i.append( elem_i_j )
            
            resultado.add_row(linha_i)
                
        return resultado
        
    def multiplicar_escalar(self,escalar):
        result = Matriz()
        
        for i in range(0,self.rows):
            linha_i = []
            for j in range(0,self.cols):
                linha_i.append( self.items[i][j]*escalar )
            
            result.add_row(linha_i)
        
        return result
                
    def transposta(self):
        mt = Matriz()
        
        for j in range(0,self.cols):
            ln = []
            for i in range(0,self.rows):
                ln.append( self.items[i][j] )
                
            mt.add_row(ln)
                
        return mt
                
    def normal(self):
        normal = 0
        for i in range(0,self.rows):
            soma = 0
            for j in range(0,self.cols):
                soma+= pow( self.items[i][j],2 )
                
            normal+= soma
            
        return pow( normal, 0.5 )    
    
# OPERATIONS
def getNeighbors( r, c, img,limit ):
    nr = r-1
    nc = c-1
    
    max_row,max_col = img.size
    neighbors = []
    
    for i in range(nr,nr+limit):
        if i>= max_row or i<=-1:
            continue
            
        for j in range(nc,nc+limit):
            if j>= max_col or j<=-1:
                continue        

            neighbors.append( img.getpixel( (i,j) ) )
            
    return neighbors
    
def getDiffPixels( p1,p2,ignoredColor ):

    if p1 == ignoredColor or p2 == ignoredColor:
        return 0

    r = abs(p1[0]-p2[0])
    g = abs(p1[1]-p2[1])
    b = abs(p1[2]-p2[2])
    
    return r+g+b

def getDiffMatrix( img,curva,ignoredColor,limit ):

    maxDiff = 0
    diffMatrix = []

    for p in curva.pontos:
        r = p[0]
        c = p[1]
                
        pixel = img.getpixel( (r,c) )
        if pixel == ignoredColor:
            pass    
        else:
            neighborhood = getNeighbors( r,c,img,limit )
            maxLocal = 0
            
            for i in range( 0,len(neighborhood) ):
                    diff = getDiffPixels( neighborhood[i],pixel,ignoredColor )
                    if diff>maxLocal:
                        maxLocal = diff
            
            diffMatrix.append( (r,c,maxLocal) )                            
                        
            if maxLocal > maxDiff:
                maxDiff = maxLocal

    return ( diffMatrix, maxDiff )    

# -- OPERATIONS --
